package com.atguigu.gmall.product.controller;

import java.util.concurrent.*;

public class TestCompletableFuture {

    /*
        CompletableFuture 提供了四个静态方法来创建一个异步操作
             public static CompletableFuture<Void> runAsync(Runnable runnable)
             public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)
             public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
             public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor)

            没有指定 Executor 的方法会使用 ForkJoinPool.commonPool() 作为它的线程池执行异步代码,如果指定线程池,则	。
                - runAsync 方法不支持返回值
                - supplyAsync 可以支持返回值
     */
    public static void main1(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个没有返回值的异步对象
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("没有返回值结果");
        });
        System.out.println(future.get());

        // 创建一个有返回值的对象
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {

            // 制造异常
            int a = 1 / 0;

            return 404;
        });
//        System.out.println(completableFuture.get());


        /*
            whenComplete: 和异步对象使用同一个线程

                result 异步对象执行后的返回值结果
                error 异常对象,如执行代码发生错误时,返回相应异常
         */
        CompletableFuture<Integer> integerCompletableFuture = completableFuture.whenComplete((result, error) -> {
            System.out.println("result:" + result);
            System.out.println("error:" + error);
        });

        // 只处理异常回调
        integerCompletableFuture.exceptionally((error) -> {
            System.out.println(error);
            return 12;
        });
//        System.out.println(integerCompletableFuture.get());


        // 与异步对象有可能不使用同个线程,由线程池重新分配
        integerCompletableFuture.whenCompleteAsync((result, error) -> {

        });
    }


    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(50, 500, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10000));

        // 创建一个异步对象 A
        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
            return "404";
        });

        // 创建一个异步对象 B
        futureA.thenAcceptAsync(result -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("我是 B");
        }, threadPoolExecutor);

        // 创建一个异步对象 C
        futureA.thenAcceptAsync(result -> {
            System.out.println("我是 C");
        }, threadPoolExecutor);
    }
}
